home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 406_01 / atoc / atoc.doc < prev    next >
Encoding:
Text File  |  1993-11-09  |  4.8 KB  |  148 lines
  1. ATOC - ANSI to K&R C translator
  2. --------------------------------
  3.  
  4. ATOC is a simple program that converts ANSI-standard C programs to a
  5. form compilable by older K&R compilers. ATOC was written by Mike Rejsa
  6. of Minneapolis, MN, and is placed by the author into the public domain
  7. for general usage at no cost.
  8.  
  9. DISCLAIMER: THE AUTHOR IS IN NO WAY RESPONSIBLE FOR USE OR MISUSE OF
  10. THIS SOFTWARE, AND TAKES NO RESPONSIBILITY FOR ANY DAMAGE OF ANY KIND
  11. RESULTING FROM USE OF THE SOFTWARE.
  12.  
  13. A typical ATOC user would be one who is forced and/or perfectly happy
  14. to use an older pre-ANSI compiler with newer ANSI-style source code.
  15. Older compilers frequently run faster and require much less in the way
  16. of machine resources (memory, disk, etc.) than newer ones. Updating can
  17. be tough either because of the expense or because only a limited
  18. computer is available for use.
  19.  
  20. ATOC is written in K&R style C. If you think about it for a minute,
  21. this makes perfect sense... if you have an ANSI compiler, you don't
  22. need ATOC. I tried hard to make it clean, generic, and portable.
  23.  
  24.  
  25.     Usage: ATOC [-e] [-i] [-il] [-t] [-v] infile [ outfile ]
  26.  
  27. Examples of usage:
  28.  
  29.     ATOC file.c        (convert and output to display)
  30.  
  31.     ATOC file.c out.c    (convert and save)
  32.  
  33.     ATOC -v file.c out.c    (convert and save with -v option)
  34.  
  35. The -e option will cause enumerations to be left alone. Some K&R
  36. compilers support enumerations.
  37.  
  38. The -i option will cause #include files to be included, converted, and
  39. placed in the output stream. Use ATOC without -i for simple one-time
  40. conversion, like if you have an ANSI program that you want to permanently
  41. convert to K&R style. Use ATOC with -i when you are maintaining ANSI
  42. code and wish to convert an included header 'on-the-fly' each time you
  43. recompile using your K&R compiler.
  44.  
  45. The -il option is just like -i except that only the local #include
  46. files (those whose name is in " " characters) are included and
  47. converted inline. If an #include files name is in < > characters,
  48. it is left as a normal #include statement. (These are often header
  49. files that come with the compiler, and as such would not be ANSI-C.)
  50.  
  51. The -t option will cause trigraphs to be left alone. (Note: If an
  52. older compiler supported trigraphs, they may not be ANSI-standard
  53. trigraphs and would therefore pass thru ATOC unchanged anyway.)
  54.  
  55. The -v option will cause voids to be left alone. Some K&R compilers
  56. support the void data type. (Note: A void used to indicate an empty
  57. function parameter list (e.g.  int func( void ) ) is always removed,
  58. even when using the -v option.)
  59.  
  60.  
  61. Since ATOC is a line-by-line translator, several parts of ATOC need
  62. a reasonable amount of standard formatting by the programmer. This is
  63. especially important around function declarations and prototypes, where
  64. it is required that the whole thing is contained on one physical line,
  65. and that the closing paren is the last thing on that line except for
  66. a semicolon and/or a comment. Also, enumerations must be completely
  67. contained on one physical line.
  68.  
  69.  
  70. The following operations are performed:
  71.  
  72.         ANSI style            Translates to:
  73.         --------------------------    ---------------------
  74. Prototypes    int func( int a, int b );    int func();
  75. (must be on
  76. one line!)
  77.  
  78. Declarations    int func( int a, int b )    int func( a, b )
  79. (must be on    {                int a;
  80. one line!)                    int b;
  81.                         {
  82.  
  83. Comments    // C++ style comment        /* comment */
  84.  
  85. Void        void func( void )        int func()
  86.         void *p;            int *p;
  87.  
  88. Void using    void func( void )        void func()
  89. -v option
  90.         There is no special handling for ++p, etc. since you
  91.         shouldn't be using pointer math on a void pointer.
  92.  
  93. Const, signed,    const int x;            int x;
  94. and volatile    signed int y;            int y;
  95. removed        volatile int z;            int z;
  96.  
  97. Enumerations    enum food { apple, pear = 2 };    #define apple 0
  98. (must be on                    #define pear 2
  99. one line!)
  100.         enum food a;            int a;
  101.         a = pear;            a = pear;
  102.  
  103. Initialized    {                { /* made static */
  104. automatic       int a[] = {1,2};           static int a[] = {1,2};
  105. aggregates
  106. (except typedef'd types)
  107.  
  108. goto labels    label:                label: ;
  109.                         (ANSI requires a statement)
  110.  
  111. Preprocessor      #anystatement            removes leading spaces
  112. statements    #if defined            #ifdef
  113.         #if ! defined            #ifndef
  114.         #elif                #else/#if/#endif
  115.  
  116. ANSI constants    \a                \007 or \057 (ASCII/EBCDIC)
  117.         \v                \013 or \013 (ASCII/EBCDIC)
  118.         \xnn (hex constant)        \nnn (octal constant)
  119.  
  120. Std macros    __STDC__            ignored, left as is
  121.         __LINE__            replaced with line number
  122.         __FILE__            replaced with "filename"
  123.         __DATE__            replaced with "Mmm dd yyyy"
  124.         __TIME__            replaced with "hh:mm:ss"
  125.  
  126. Trigraphs
  127.         ??<                {
  128.         (etc.)
  129.  
  130.  
  131. The following ANSI items are not handled, but may be covered in
  132. future versions:
  133.  
  134.     New-style function pointers
  135.  
  136.     Unsigned constants (123u 456U)
  137.  
  138.     Adjacent string concatenation
  139.  
  140.     # string literal operator
  141.  
  142.     ## token pasting operator
  143.  
  144.  
  145. Use and enjoy - long live C!
  146.  
  147. -mike rejsa, 10/92
  148.